/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */

package nominalitzacions.drivers;

import java.util.*;
import commonlib.domain.*;
import nominalitzacions.persistance.*;
import java.io.*;

/**
 * Aquesta classe implementa un driver interactiu per testejar la classe
 * RuleGenerator.
 *
 * Per implementar-lo s'ha utilitzat les classes Corpus, ABPair i
 * VerbCorpusDataManager que es suposen testades i que funcionen correctament.
 *
 * El funcionament es senzill. Per testejar les regles generades per un sol
 * parell cal utilitzar l'opcio 1. Si volem generar les de tot un corpus
 * utilitzarem la opcio 2. En aquest cas nomes funcionara correctament si el
 * fitxer passat te l'estructura del corpus de parells de verbs.
 *
 * @author genis.sole
 */
public class RuleGeneratorDriver {
    public static void main(String [] args) {
        System.out.println("Escull una opcio");
        printOptions();
        boolean done = false;
        while (!done) {
            Scanner scOptions = new Scanner(System.in);
            switch(scOptions.nextInt()) {
                case 0:
                    done = true;
                    break;
                case 1:
                    mode1();
                    break;
                case 2:
                    try {
                        long start = new Date().getTime();
                        mode2();
                        long end = new Date().getTime();
                        long estimatedTime = end - start;
                        System.out.println("time: " + estimatedTime);

                    } catch (IOException IOEx) {
                        System.out.println(IOEx);
                    }
                    break;
                case 3:
                    printOptions();
                    break;
                default:
                    System.out.println("opcio incorrecta");
                    break;
            }
            if (!done) {
                System.out.println("Escull una altra opcio");
            }
        }
    }

    private static void printOptions() {
        System.out.println("+----------------------------------------------+");
        System.out.println("|                  OPCIONS                     |");
        System.out.println("+----------------------------------------------+");
        System.out.println("| 1. consultar regles de un parell             |");
        System.out.println("| 2. consultar regles de un fitxer de parells  |");
        System.out.println("| 3. consultar opcions                         |");
        System.out.println("| 0. sortir                                    |");
        System.out.println("+----------------------------------------------+");
    }

    private static void mode1() {
        Scanner sc = new Scanner(System.in);
        System.out.println("Entrar parell alpha-beta");
        System.out.print("Entrat alpha: ");
        String alpha = sc.next();
        System.out.print("Entrar beta: ");
        String beta = sc.next();
        System.out.print("Entrar N: ");
        int n = sc.nextInt();

        RuleGenerator ruleGen =  new RuleGenerator();
        ArrayList<ABPair> rules = ruleGen.levNAssociation(alpha, beta, n);
        
        printRules(rules, alpha, beta, n);
    }

    private static void mode2() throws IOException {
        
        System.out.print("Defineix N: ");
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        System.out.print("Entra ruta del fitxer: ");
        VerbCorpusDataManager VCDM = new VerbCorpusDataManager(sc.next());

        Corpus corpus = VCDM.readCorpus();
        Iterator<ABPair> it = corpus.iterator();
        RuleGenerator ruleGen = new RuleGenerator();
        Rules ruleTree = new Rules();

        while (it.hasNext()) {
            ABPair pair = it.next();
            String alpha = pair.getAlpha();
            String beta = pair.getBeta();
            ArrayList<ABPair> rules = ruleGen.levNAssociation(alpha, beta, n);
            for (int i = 0; i < rules.size(); ++i) {
                ruleTree.addRule(rules.get(i), 1);
            }
        }
        System.out.println(ruleTree.findRule(new ABPair("eta","noita")));
        System.out.println("probabilitat de ation -> eta:"
                + ruleTree.getRuleProb(new ABPair("eta", "noita")));
    }

    private static void printRules(ArrayList<ABPair> rules, String alpha,
                                   String beta, int n) {
        System.out.println("Les regles generades amb alpha *" + alpha
                           + "* i beta *" + beta + "* amb N = " + n + " son:");
        
        for (int i = 0; i < rules.size(); ++i) {
            System.out.println(rules.get(i).getAlpha()+" -> "
                               + rules.get(i).getBeta());
        }
    }
}
